真正掌握 Rust 的關鍵，始於 DRY（不要重複自己） 原則。在嘗試使用泛型語法之前，我們必須走過 具體抽象的道路。想像一個零售應用程式，比較價格（i32）與感測器溫度（f32）；將比較邏輯重複貼上，會產生 技術負債 使錯誤在重複的陰影中滋生蔓延。
1. 重構流程
要從重複走向優雅，請遵循三步驟提取法： 辨識 重複的邏輯， 提取 將該邏輯提取至函數主體，並明確定義輸入與輸出，再 更新 原始呼叫點以使用新函數。
2. 具體邏輯的限制
雖然 清單 10-3 成功抽象了邏輯，但仍受限於 具體資料類型。它解決了邏輯重複的問題，卻使我們容易受到 類型重複的威脅。這道天花板正是推動 抽象類型 （$
main.py
TERMINALbash — 80x24
> Ready. Click "Run" to execute.
>
QUESTION 1
According to the 'Path to Robust Abstraction', what is the first step in the refactoring workflow?
Defining a generic type parameter <T>.
Identifying repeated logic in the codebase.
Compiling the code to check for borrow errors.
Implementing the PartialOrd trait.
✅ Correct!
Correct! You must first recognize duplication before you can abstract it.❌ Incorrect
Generic parameters come later. The first step is identification of duplicate concrete logic.QUESTION 2
What does Listing 10-4 represent in this lesson context?
A fully generic implementation of a search algorithm.
Two functions that differ only in names and signatures (Technical Debt).
A specialized trait for temperature sensors.
The final state of robust abstraction.
✅ Correct!
Yes. Listing 10-4 shows the duplication (i32 vs char) that we want to eliminate.❌ Incorrect
Listing 10-4 is the 'before' state, showing the cost of duplication across types.QUESTION 3
Why is Listing 10-3 considered a 'partial' success in abstraction?
It fails to find the largest number correctly.
It requires the heap for all calculations.
It abstracts the logic but remains bound to a Concrete Data Type (i32).
It uses too many lifetime annotations.
✅ Correct!
Exactly. It handles logic duplication but not type duplication.❌ Incorrect
The logic is correct, but it is restricted to i32, meaning it isn't truly generic yet.QUESTION 4
What is the specific 'debt' created by having two functions with identical logic for different types?
Increased binary size due to monomorphization.
Logic updates must be applied manually in multiple places.
Compile times are significantly reduced.
It bypasses the borrow checker.
✅ Correct!
This is the core of maintenance debt—updating the 'comparison' logic in one place won't fix it in the other.❌ Incorrect
Manual updates in multiple places increase the surface area for bugs and logic drift.QUESTION 5
What serves as the 'catalyst' for moving toward Abstract Types like Generics?
The desire for slower runtime performance.
Running out of stack memory.
The realization that concrete abstraction doesn't solve type duplication.
The need for global variables.
✅ Correct!
Generics are the solution to the limitations of concrete functions like the one in Listing 10-3.❌ Incorrect
Generics solve the problem of repeating logic across different types.Case Study: Scaling the Retail App
Applying Concrete Abstraction to Price and Inventory Data
You have a retail application that currently uses two loops: one to find the most expensive 'Item' (Price: i32) and one to find the highest 'Quantity' (Stock: i32) in a warehouse list. You want to apply the 'Path to Robust Abstraction'.
Q
1. How would you apply the first two steps of the refactoring workflow to these two loops?
Solution:
First, identify that both loops use identical comparison logic (if item > current_max). Second, extract this into a single function `fn largest(list: &[i32]) -> &i32` that takes a slice of integers and returns a reference to the max.
First, identify that both loops use identical comparison logic (if item > current_max). Second, extract this into a single function `fn largest(list: &[i32]) -> &i32` that takes a slice of integers and returns a reference to the max.
Q
2. If your app later adds 'Temperature' as an f32, why does the abstraction in Listing 10-3 fail to help?
Solution:
Listing 10-3 is tied to a Concrete Data Type (i32). While the logic is the same, the function signature `&[i32]` will reject a slice of `f32`, forcing you back into type duplication until Generics are introduced.
Listing 10-3 is tied to a Concrete Data Type (i32). While the logic is the same, the function signature `&[i32]` will reject a slice of `f32`, forcing you back into type duplication until Generics are introduced.